home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / CPP / LINKLIST.ZIP / VOIDLIST.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-02  |  5.3 KB  |  299 lines
  1. ///////////////////////////////////////////////////////
  2. //                                                   //
  3. //   Linked List Class Functions - Version 1.24      //
  4. //                             //
  5. //           By Kevin Campbell 1/12/96               //
  6. //                                                   //
  7. //                                                   //
  8. ///////////////////////////////////////////////////////
  9.  
  10. #include "linklist\voidlist.h"
  11. #include <string.h>
  12. #include <stdlib.h>
  13. #include <stdio.h>
  14. #include <conio.h>
  15. #include <alloc.h>
  16.  
  17. char void_list::add(void *tempdata){
  18.   char *tempstore;
  19.   struct voidinfo *nextlink;
  20.   struct voidinfo *templink;
  21.  
  22.   if (templink=new voidinfo){
  23.     if (curr){ // curr exists and should be linked from
  24.  
  25.       // Preserve Structure
  26.  
  27.       nextlink=curr->link;
  28.  
  29.       templink->link=curr->link;
  30.       templink->oldlink=curr;
  31.  
  32.       nextlink->oldlink=templink;
  33.       curr->link=templink;
  34.  
  35.       templink->data=tempdata;
  36.  
  37.       curr=templink; // Set current Linked-List position to new struct
  38.  
  39.       curr_entry++;
  40.  
  41.       ///////////////////////////////////
  42.  
  43.     }else{
  44.       // Linked List does not exist
  45.       // Create new linked list structure
  46.  
  47.       templink->link=NULL;
  48.       templink->oldlink=NULL;
  49.       templink->data=tempdata;
  50.       curr=templink;
  51.       curr_entry++;
  52.     }
  53.     entries++;
  54.   }else{
  55.     terminate("Malloc Failure - Linked list - Node allocation");
  56.   }
  57.   return(1);
  58. }
  59.  
  60. char void_list::kill(void){
  61.   struct voidinfo *templink;
  62.   struct voidinfo *nextlink;
  63.   struct voidinfo *oldlink;
  64.  
  65.   if(!(curr==NULL)){ // if curr exists
  66.  
  67.     // Detach and Rebuild Structure
  68.  
  69.     nextlink=curr->link;
  70.     oldlink=curr->oldlink;
  71.  
  72.     if(oldlink)oldlink->link=nextlink;
  73.     if(nextlink)nextlink->oldlink=oldlink;
  74.  
  75.     // Entry is now completely removed from structure
  76.  
  77.     templink=curr; // Store removed entry address for deallocation
  78.  
  79.     ///////////////////////////////////
  80.  
  81.     if ((curr->link==NULL)&(curr->oldlink==NULL)){
  82.       curr=NULL;
  83.       curr_entry=0;
  84.     }else{
  85.       if(curr->link==NULL){
  86.     curr=curr->oldlink;
  87.     curr_entry--;
  88.       }else{
  89.     curr=curr->link;
  90.       }
  91.     }
  92.  
  93.     delete templink; // Deallocate memory and return to heap
  94.     entries--;
  95.  
  96.     return(1);
  97.  
  98.   }else{
  99.     return(0);
  100.   }
  101. }
  102.  
  103. void void_list::link(voidinfo *entry){
  104.   curr=entry;
  105.   count();
  106. }
  107.  
  108. voidinfo *void_list::cutfront(){
  109.   voidinfo *tempptr;
  110.   if(curr){
  111.     tempptr=curr->oldlink;
  112.     curr->oldlink=NULL; // Cap main list end
  113.     if(tempptr)tempptr->link=NULL; // Cap aux list start
  114.     count();
  115.     return(tempptr);
  116.   }else{
  117.     return(NULL);
  118.   }
  119. }
  120.  
  121. voidinfo *void_list::cutend(){
  122.   voidinfo *tempptr;
  123.   if(curr){
  124.     tempptr=curr->link;
  125.     curr->link=NULL;       // Cap main list start
  126.     if(tempptr)tempptr->oldlink=NULL; // Cap aux list end
  127.     count();
  128.     return(tempptr);
  129.   }else{
  130.     return(NULL);
  131.   }
  132. }
  133.  
  134. char void_list::nuke(void){
  135.   if(curr){
  136.     while(kill());
  137.     return(1);
  138.   }else{
  139.     return(0);
  140.   }
  141. }
  142.  
  143. char void_list::put(void *info){
  144.   if(!(curr==NULL)){
  145.     curr->data=info;
  146.     return(1);
  147.   }else{
  148.     //Linked list does not exist, return error
  149.     return(0);
  150.   }
  151. }
  152.  
  153. void *void_list::get(void){
  154.   if(!(curr==NULL)){
  155.     return(curr->data);
  156.   }else{
  157.     //Linked list does not exist, return error
  158.     return(NULL);
  159.   }
  160. }
  161.  
  162. char void_list::find(void *fdata){
  163.   rw();
  164.   do{
  165.     if(curr->data==fdata)return(1); // leaves linked list at position
  166.   }while(next());
  167.   return(0);
  168. }
  169.  
  170. char void_list::last(){
  171.   if(curr){
  172.     if(curr->oldlink){
  173.       curr=curr->oldlink;
  174.       curr_entry--;
  175.       return(1);
  176.     }else{
  177.       return(0);
  178.     }
  179.   }else{
  180.     return(0);
  181.   }
  182. }
  183.  
  184. char void_list::next(){
  185.   if(curr){
  186.     if(curr->link){
  187.       curr=curr->link;
  188.       curr_entry++;
  189.       return(1);
  190.     }else{
  191.       return(0);
  192.     }
  193.   }else{
  194.     return(0);
  195.   }
  196. }
  197.  
  198.  
  199. char void_list::rw(){
  200.   if(curr){
  201.     while (last());
  202.     return(1);
  203.   }else{
  204.     return(0);
  205.   }
  206. }
  207.  
  208. char void_list::ff(){
  209.   if(curr){
  210.     while (next());
  211.     return(1);
  212.   }else{
  213.     return(0);
  214.   }
  215. }
  216.  
  217. void void_list::count(void){
  218.   entries=0;
  219.   curr_entry=1;
  220.   if(curr){
  221.     rw();
  222.     do{
  223.       entries++;
  224.     }while(next());
  225.   }
  226. }
  227.  
  228. int void_list::num(){
  229.   return(entries);
  230. }
  231.  
  232. void *void_list::addr(){
  233.   if(curr){
  234.     return(curr->data);
  235.   }else{
  236.     return(NULL);
  237.   }
  238. }
  239.  
  240. char void_list::use(int entry){
  241.   while(curr_entry!=entry){
  242.     if(curr_entry>entry){
  243.       if(!last())return(0); // Failed
  244.     }else{
  245.       if(!next())return(0); // Failed
  246.     }
  247.   };
  248.   return(1); // Pass :)
  249. }
  250.  
  251. void_list::void_list(){
  252.   entries=0;
  253.   curr=NULL;
  254.   data=NULL;
  255.   curr_entry=0;
  256. }
  257.  
  258. void_list::~void_list(){
  259.   nuke();//while(kill());
  260. }
  261.  
  262.  
  263.  
  264.  
  265. char void_list::operator=(void *info){
  266.   if(!(curr==NULL)){
  267.     curr->data=info;
  268.     return(1);
  269.   }else{
  270.     //Linked list does not exist, return error
  271.     return(0);
  272.   }
  273. }
  274.  
  275. char void_list::operator--(int x){
  276.   if(curr){
  277.     if(curr->oldlink){
  278.       curr=curr->oldlink;
  279.       return(1);
  280.     }else{
  281.       return(0);
  282.     }
  283.   }else{
  284.     return(0);
  285.   }
  286. }
  287.  
  288. char void_list::operator++(int x){
  289.   if(curr){
  290.     if(curr->link){
  291.       curr=curr->link;
  292.       return(1);
  293.     }else{
  294.       return(0);
  295.     }
  296.   }else{
  297.     return(0);
  298.   }
  299. }